let Article = require("../model/article");

// 发布文章
const addArticle = async (ctx) => {
  let article = ctx.request.body;
  await Article.create(article)
    .then((rel) => {
      if (rel) {
        ctx.body = {
          code: 200,
          msg: "文章发布成功",
        };
      } else {
        ctx.body = {
          code: 300,
          msg: "文章发布失败",
        };
      }
    })
    .catch((err) => {
      ctx.body = {
        code: 500,
        msg: "文章发布异常",
      };
    });
};

//查询所有文章（分页）api
const findAllArticles = async (ctx) => {
  let { page, author } = ctx.query;
  // 判断页码
  if (!page || isNaN(Number(page))) {
    page = 1;
  } else {
    page = Number(page);
  }
  // 每页的条数
  let pagesize = 10;

  // 计算总页数
  let count = 0; //总条数
  await Article.find({ author })
    .count()
    .then((rel) => {
      count = rel;
    });
  let totalPage = 0;
  if (count > 0) {
    //    向上取整
    totalPage = Math.ceil(count / pagesize);
  }

  //  判断当前页码的范围
  if (page > 0 && page > totalPage) {
    page = totalPage;
  } else if (page < 1) {
    page = 1;
  }

  //   skip 是查询的起始位置  limit 是每页要查询多少条数据
  // 计算起始位置
  let start = (page - 1) * pagesize;
  await Article.find({ author })
    .skip(start)
    .limit(pagesize)
    .then((rel) => {
      if (rel && rel.length > 0) {
        ctx.body = {
          code: 200,
          msg: "文章查询成功",
          result: rel,
          page, //当前页码
          pagesize, //每页条数
          count, //总条数
        };
      } else {
        ctx.body = {
          code: 300,
          msg: "无查询结果",
        };
      }
    })
    .catch((err) => {
      ctx.body = {
        code: 500,
        msg: "查询结果异常",
      };
    });
};

// 查询单个文章
const findOneArticle = async (ctx) => {
  let { id } = ctx.query;
//   判断当前   查询是否成功
let isRead = false
  await Article.findOne({ id })
    .then((rel) => {
      if (rel) {
        isRead =true
        ctx.body = {
          code: 200,
          msg: "查询成功",
          result: rel
        };
      } else {
        ctx.body = {
          code: 300,
          msg: "文章查询失败",
        };
      }
    })
    .catch((err) => {
      ctx.body = {
        code: 500,
        msg: "文章查询时出现异常",
        err,
      };
    });
 
    if (isRead==true ) {
        // 自增 $inc   read：1 read自增一
        await Article.updateOne({id},{$inc:{read:1}}) 
    }

};

// 修改文章接口
const updataArticle = async (ctx) => {
  let article = ctx.request.body;
  await Article.updateOne(
    { id: article.id },
    { title: article.title,
     stemfrom: article.stemfrom,
    content:article.content,
    articleImg:article.articleImg
    }
  ).then(rel=>{
     if (rel.modifiedCount>0) {
         ctx.body = {
             code:200,
             msg:'文章修改成功'
         }
     }else{
         ctx.body = {
             code:300,
             msg:'文章修改失败'
         }
     }
  }).catch(err=>{
      ctx.body = {
          code:500,
          msg:"文章修改异常"
      }
  })
};


// 删除文章接口
const delArticle = async ctx =>{
    let {id} = ctx.request.body
    await Article.deleteOne({id}).then(rel=>{
        if (rel) {
            ctx.body = {
                code:200,
                msg:'删除文章成功'
            }
        }else{
            ctx.body = {
                code:300,
                msg:'删除文章失败'
            }
        }
    }).catch(err=>{
        ctx.body = {
            code:500,
            msg:'删除文章异常',
            err
        }
    })
}

            //  前端部分
// 随机查询文章（前端）
const findAll = async (ctx) => {
  let { page } = ctx.query;
  // 判断页码
  if (!page || isNaN(Number(page))) {
    page = 1;
  } else {
    page = Number(page);
  }
  // 每页的条数
  let pagesize = 10;

  // 计算总页数
  let count = 0; //总条数
  await Article.find()
    .count()
    .then((rel) => {
      count = rel;
    });
  let totalPage = 0;
  if (count > 0) {
    //    向上取整
    totalPage = Math.ceil(count / pagesize);
  }
  //  判断当前页码的范围
  if (page > 0 && page > totalPage) {
    page = totalPage;
  } else if (page < 1) {
    page = 1;
  }
  //   skip 是查询的起始位置  limit 是每页要查询多少条数据
  // 计算起始位置
  let start = (page - 1) * pagesize;
  await Article.find()
    .skip(start)
    .limit(pagesize)
    .sort({createTime:-1})
    .then((rel) => {
      if (rel && rel.length > 0) {
        ctx.body = {
          code: 200,
          msg: "文章查询成功",
          result: rel,
          page, //当前页码
          pagesize, //每页条数
          count, //总条数
        };
      } else {
        ctx.body = {
          code: 300,
          msg: "无查询结果",
        };
      }
    })
    .catch((err) => {
      ctx.body = {
        code: 500,
        msg: "查询结果异常",
      };
    });
};

// 根据阅读量排行文章（前端）
const findViewAll = async (ctx) => {
  let { page } = ctx.query;
  // 判断页码
  if (!page || isNaN(Number(page))) {
    page = 1;
  } else {
    page = Number(page);
  }
  // 每页的条数
  let pagesize = 10;

  // 计算总页数
  let count = 0; //总条数
  await Article.find()
    .count()
    .then((rel) => {
      count = rel;
    });
  let totalPage = 0;
  if (count > 0) {
    //    向上取整
    totalPage = Math.ceil(count / pagesize);
  }
  //  判断当前页码的范围
  if (page > 0 && page > totalPage) {
    page = totalPage;
  } else if (page < 1) {
    page = 1;
  }
  //   skip 是查询的起始位置  limit 是每页要查询多少条数据
  // 计算起始位置
  let start = (page - 1) * pagesize;
  await Article.find()
    .skip(start)
    .limit(pagesize)
    .sort({read:-1})
    .then((rel) => {
      if (rel && rel.length > 0) {
        ctx.body = {
          code: 200,
          msg: "文章查询成功",
          result: rel,
          page, //当前页码
          pagesize, //每页条数
          count, //总条数
        };
      } else {
        ctx.body = {
          code: 300,
          msg: "无查询结果",
        };
      }
    })
    .catch((err) => {
      ctx.body = {
        code: 500,
        msg: "查询结果异常",
      };
    });
};
module.exports = {
  addArticle,
  findAllArticles,
  findOneArticle,
  findAll,
  findViewAll,
  updataArticle,
  delArticle
};
